//package cate.common.util;
//
//import lombok.extern.slf4j.Slf4j;
//import sun.misc.Unsafe;
//
//import java.lang.reflect.Array;
//import java.lang.reflect.Field;
//import java.lang.reflect.Modifier;
//import java.util.*;
//
///**
// * 计算对象占用内存
// */
//@Slf4j
//public class SizeOf {
//    public static void print(Object object) {
//        ObjectInfo.printObj(object, false);
//    }
//
//    public static void printDetail(Object object) {
//        ObjectInfo.printObj(object, true);
//    }
//
//    private static class ObjectInfo {
//        public  String name;
//        public  String type;
//        public  String contents;
//        public  int offset;
//        public  int length;
//        public  int arrayBase;
//        public  int arrayElementSize;
//        public  int arraySize;
//        public List<ObjectInfo> children;
//
//        protected ObjectInfo(String name, String type, String contents, int offset, int length, int arraySize,
//                             int arrayBase, int arrayElementSize) {
//            this.name = name;
//            this.type = type;
//            this.contents = contents;
//            this.offset = offset;
//            this.length = length;
//            this.arraySize = arraySize;
//            this.arrayBase = arrayBase;
//            this.arrayElementSize = arrayElementSize;
//            children = new ArrayList<>(1);
//        }
//
//        public void addChild(ObjectInfo info) {
//            if (info != null) {
//                children.add(info);
//            }
//        }
//
//        public long getDeepSize() {
//            return addPaddingSize(arraySize + getUnderlyingSize(arraySize != 0));
//        }
//
//        long size = 0;
//
//        private long getUnderlyingSize(boolean isArray) {
//            for (ObjectInfo child : children) {
//                size += child.arraySize + child.getUnderlyingSize(child.arraySize != 0);
//            }
//            if (!isArray && !children.isEmpty()) {
//                int tempSize = children.get(children.size() - 1).offset + children.get(children.size() - 1).length;
//                size += addPaddingSize(tempSize);
//            }
//            return size;
//        }
//
//        private static  class OffsetComparator implements Comparator<ObjectInfo> {
//            @Override
//            public int compare(ObjectInfo o1, ObjectInfo o2) {
//                return o1.offset - o2.offset;
//            }
//        }
//
//        public void sort() {
//            Collections.sort(children, new OffsetComparator());
//        }
//
//        @Override
//        public String toString() {
//            StringBuilder sb = new StringBuilder();
//            toStringHelper(sb, 0);
//            return sb.toString();
//        }
//
//        private void toStringHelper(StringBuilder sb, int depth) {
//            depth(sb, depth).append("name=").append(name).append(", type=").append(type)
//                    .append(", contents=").append(contents).append(", offset=").append(offset)
//                    .append(", length=").append(length);
//            if (arraySize > 0) {
//                sb.append(", arrayBase=").append(arrayBase);
//                sb.append(", arrayElemSize=").append(arrayElementSize);
//                sb.append(", arraySize=").append(arraySize);
//            }
//            for ( ObjectInfo child : children) {
//                sb.append('\n');
//                child.toStringHelper(sb, depth + 1);
//            }
//        }
//
//        private StringBuilder depth(StringBuilder sb, int depth) {
//            for (int i = 0; i < depth; ++i) {
//                sb.append("\t");
//            }
//            return sb;
//        }
//
//        private long addPaddingSize(long size){
//            if(size % 8 != 0){
//                return (size / 8 + 1) * 8;
//            }
//            return size;
//        }
//
//        public static class ClassIntrospector {
//            private static Unsafe UNSAFE;
//            private static  int OBJECT_REF_SIZE;
//            static {
//                try {
//                    Field field = Unsafe.class.getDeclaredField("theUnsafe");
//                    field.setAccessible(true);
//                    UNSAFE = (Unsafe) field.get(null);
//
//                    OBJECT_REF_SIZE = UNSAFE.arrayIndexScale(Object[].class);
//                } catch (Exception e) {
//                    throw new RuntimeException(e);
//                }
//            }
//
//            private static Map<Class<?>, Integer> primitiveSizes;
//
//            static {
//                primitiveSizes = new HashMap<>(7);
//                primitiveSizes.put(byte.class, 1);
//                primitiveSizes.put(char.class, 2);
//                primitiveSizes.put(int.class, 4);
//                primitiveSizes.put(long.class, 8);
//                primitiveSizes.put(float.class, 4);
//                primitiveSizes.put(double.class, 8);
//                primitiveSizes.put(boolean.class, 1);
//            }
//
//            public ObjectInfo introspect(Object obj)
//                    throws IllegalAccessException {
//                try {
//                    return introspect(obj, null);
//                } finally {
//                    m_visited.clear();
//                }
//            }
//
//            private IdentityHashMap<Object, Boolean> m_visited = new IdentityHashMap<>(
//                    100);
//
//            private ObjectInfo introspect(Object obj, Field fld)
//                    throws IllegalAccessException {
//                boolean isPrimitive = fld != null && fld.getType().isPrimitive();
//                boolean isRecursive = false;
//                if (!isPrimitive) {
//                    if (m_visited.containsKey(obj)) {
//                        isRecursive = true;
//                    }
//                    m_visited.put(obj, true);
//                }
//
//                Class<?> type = (fld == null || (obj != null && !isPrimitive)) ? obj
//                        .getClass() : fld.getType();
//                int arraySize = 0;
//                int baseOffset = 0;
//                int indexScale = 0;
//                if (type.isArray() && obj != null) {
//                    baseOffset = UNSAFE.arrayBaseOffset(type);
//                    indexScale = UNSAFE.arrayIndexScale(type);
//                    arraySize = baseOffset + indexScale * Array.getLength(obj);
//                }
//
//                ObjectInfo root;
//                if (fld == null) {
//                    root = new ObjectInfo("", type.getCanonicalName(), getContents(obj,
//                            type), 0, getShallowSize(type), arraySize, baseOffset,
//                            indexScale);
//                } else {
//                    int offset = (int) UNSAFE.objectFieldOffset(fld);
//                    root = new ObjectInfo(fld.getName(), type.getCanonicalName(),
//                            getContents(obj, type), offset, getShallowSize(type),
//                            arraySize, baseOffset, indexScale);
//                }
//
//                if (!isRecursive && obj != null) {
//                    if (isObjectArray(type)) {
//                        // introspect object arrays
//                        Object[] ar = (Object[]) obj;
//                        for (Object item : ar) {
//                            if (item != null) {
//                                root.addChild(introspect(item, null));
//                            }
//                        }
//                    } else {
//                        for (Field field : getAllFields(type)) {
//                            if ((field.getModifiers() & Modifier.STATIC) != 0
//                                    //有的对象包含非静态内部类，会有this$0属性
//                                    || field.getName().equals("this$0")) {
//                                continue;
//                            }
//                            field.setAccessible(true);
//                            root.addChild(introspect(field.get(obj), field));
//                        }
//                    }
//                }
//                root.sort();
//                return root;
//            }
//
//            private static List<Field> getAllFields(Class<?> type) {
//                if (type.isPrimitive()) {
//                    return Collections.emptyList();
//                }
//                Class<?> cur = type;
//                List<Field> res = new ArrayList<>(10);
//                while (true) {
//                    Collections.addAll(res, cur.getDeclaredFields());
//                    if (cur == Object.class) {
//                        break;
//                    }
//                    cur = cur.getSuperclass();
//                }
//                return res;
//            }
//
//            private static boolean isObjectArray(Class<?> type) {
//                if (!type.isArray()) {
//                    return false;
//                }
//                if (type == byte[].class || type == boolean[].class
//                        || type == char[].class || type == short[].class
//                        || type == int[].class || type == long[].class
//                        || type == float[].class || type == double[].class) {
//                    return false;
//                }
//                return true;
//            }
//
//            private static String getContents(Object val,  Class<?> type) {
//                if (val == null) {
//                    return "null";
//                }
//                if (type.isArray()) {
//                    if (type == byte[].class) {
//                        return Arrays.toString((byte[]) val);
//                    } else if (type == boolean[].class) {
//                        return Arrays.toString((boolean[]) val);
//                    } else if (type == char[].class) {
//                        return Arrays.toString((char[]) val);
//                    } else if (type == short[].class) {
//                        return Arrays.toString((short[]) val);
//                    } else if (type == int[].class) {
//                        return Arrays.toString((int[]) val);
//                    } else if (type == long[].class) {
//                        return Arrays.toString((long[]) val);
//                    } else if (type == float[].class) {
//                        return Arrays.toString((float[]) val);
//                    } else if (type == double[].class) {
//                        return Arrays.toString((double[]) val);
//                    } else {
//                        return Arrays.toString((Object[]) val);
//                    }
//                }
//                return val.toString();
//            }
//
//            private static int getShallowSize(Class<?> type) {
//                if (type.isPrimitive()) {
//                    Integer res = primitiveSizes.get(type);
//                    return res != null ? res : 0;
//                }
//                return OBJECT_REF_SIZE;
//            }
//        }
//
//        public static void main(String[] args) {
//            //以下计算均处于64位虚拟机，且开启指针压缩
//
//            // Integer类中只有一个非static属性 value， 大小为 8(Markword) + 4(klasspointer) + 4(Integer) = 16(无需内存对齐)
//            Integer i = new Integer(11);
//            printObj(i, true);
//
//            // HashMap 不添加元素时
//            // AbstractMap 非static属性
//            // 1. keyset <Set<K>> 4
//            // 2. values <Collection<V>> 4
//            //              +
//            // HashMap 非static属性
//            // 1. entryset <Entry<K,V>> 4
//            // 2. loadFactor float 4
//            // 3. modcount int 4
//            // 4. size int 4
//            // 5. table  Node<K,V>[] 4
//            // 6. threshold int 4
//            // 大小为 8(markword) + 4(klasspointer) + 4 + 4 + 4 + 4 + 4 + 4 + 4 + 4 = 44 + 4(内存对齐) = 48
//            Map<String, String> ii = new HashMap<>();
//            printObj(ii, true);
//
//            //hash添加元素后
//            // hashmap 48
//            // table 对象头 16 +
//            //       无值的node共 (16-1) * 4 = 60
//            //       有值的node共(12 + 4 + (4 + 48) + (4 + 48) + 4= 124 + 4内存对齐) 128
//            //       共 16 + 60 + 128 = 204 + 4内存对齐 共208
//            // 共 48 + 208 = 256
//            // Node 非static属性
//            //  对象头（markword+klasspointer）12
//            // 1. hash (int) 4
//            // 2. K (String) 4 + String对象大小 12 + 4 + 4 + (16 + 8('n','a','m','e' = 4*2) 不需要内存对齐)(char数组)
//            // 3. V (String) 4 + String对象大小 12 + 4 + 4 + (16 + 4('z','x' = 2*2) + 4内存对齐)
//            // 4. next(Node) 4
//            // String 非static属性
//            //  对象头 12
//            // 1. value (char[]) 根据数组大小判断 数组对象头16 + char元素每个2字节 + 内存对齐
//            // 2. hash int 4
//            ii.put("name","zx");
//            printObj(ii, true);
//        }
//
//        protected static void printObj(Object obj, boolean needDetail) {
//            ObjectInfo.ClassIntrospector ci = new ObjectInfo.ClassIntrospector();
//            try {
//                ObjectInfo res = ci.introspect(obj);
//                long size = res.getDeepSize();
//                if (size < 1024) {
//                    log.info("对象占用空间: {} byte", size);
//                } else if(size < 1024 * 1024) {
//                    log.info("对象占用空间: {} kb", size / 1024d);
//                } else if(size < 1024 * 1024 * 1024) {
//                    log.info("对象占用空间: {} mb", size / 1024 / 1024d);
//                } else {
//                    log.info("对象占用空间: {} gb", size / 1024 / 1024 / 1024d);
//                }
//                if (needDetail) {
//                    log.info("具体明细如下: \n\t{}", res.toString());
//                }
//            } catch (Exception e) {
//
//            }
//        }
//    }
//}
